package c97Coder;//package c97Coder;
//
//import java.io.FileInputStream;
//import java.io.IOException;
//import java.io.InputStream;
//import java.io.UnsupportedEncodingException;
//import java.security.InvalidKeyException;
//import java.security.Key;
//import java.security.KeyFactory;
//import java.security.KeyPair;
//import java.security.KeyPairGenerator;
//import java.security.KeyStore;
//import java.security.KeyStoreException;
//import java.security.NoSuchAlgorithmException;
//import java.security.PrivateKey;
//import java.security.PublicKey;
//import java.security.UnrecoverableKeyException;
//import java.security.cert.CertificateException;
//import java.security.spec.InvalidKeySpecException;
//import java.security.spec.PKCS8EncodedKeySpec;
//import java.security.spec.X509EncodedKeySpec;
//
//import javax.crypto.BadPaddingException;
//import javax.crypto.Cipher;
//import javax.crypto.IllegalBlockSizeException;
//import javax.crypto.NoSuchPaddingException;
//
//import org.slf4j.Logger;
//import org.slf4j.LoggerFactory;
//
///**
//* RSA非对称加密解密工具类。
//*
//* <p>
//* 种算法1978年就出现了，它是第一个既能用于数据加密也能用于数字签名的算法。它易于理解和操作，也很流行。 算法的名字以发明者的名字命名：Ron
//* Rivest, AdiShamir 和Leonard Adleman。 这种加密算法的特点主要是密钥的变化，RSA同时有两把钥匙，公钥与私钥。
//* 同时支持数字签名。数字签名的意义在于，对传输过来的数据进行校验。确保数据在传输工程中不被修改。
//* <p>
//* 流程分析：
//* <ol>
//* <li>甲方构建密钥对儿，将公钥公布给乙方，将私钥保留。</li>
//* <li>甲方使用私钥加密数据，然后用私钥对加密后的数据签名，发送给乙方签名以及加密后的数据；
//* 乙方使用公钥、签名来验证待解密数据是否有效，如果有效使用公钥对数据解密。</li>
//* <li>乙方使用公钥加密数据，向甲方发送经过加密后的数据；甲方获得加密数据，通过私钥解密。</li>
//* </ol>
//* <p>
//* <a href="https://github.com/wwwtyro/cryptico">前端demo<a> <br>
//* <br>
//* 创建人：梁栋【<a href="http://snowolf.iteye.com/blog/381767">原文点这<a>】 <br>
//* 创建时间：2017年10月23日 下午10:53:32 <br>
//* 修改人： <br>
//* 修改时间： <br>
//* 修改备注： <br>
//*
//* @version V1.0
//*/
//public abstract class RSACoder extends BaseCoder {
//	private static Logger logger = LoggerFactory.getLogger(BaseCoder.class);
//
//	/**
//	 * 算法类型
//	 */
//	public static final String KEY_ALGORITHM = "RSA";
//
//	/**
//	 * 填充方式：PKCS1填充（默认）
//	 * <p>
//	 * 注意：使用填充时，公钥每次加密的字符串都会不一样，这样更安全；不使用则每次都一样。因为java默认是填充的，而安卓默认不填充，
//	 * 所以安卓默认加密的密文，java默认不能解密！！必须手动指定他们用一致的填充方式，才能正确加密解密。
//	 */
//	public static final String PADDING = "RSA/ECB/PKCS1Padding";
//
//	/**
//	 * 填充方式：不填充
//	 */
//	public static final String NO_PADDING = "RSA/ECB/NoPadding";
//
//	/**
//	 * 由字节数组用Base64编码成的私钥
//	 */
//	public static String privateKey = "MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAJRuPvGT1HorIRe5U1SFD7ommre/\r\n"
//			+ "EmR3VUzvmfwgGatM415oJxjoXIAv50p/sWbHAsgdlNY6cbjnZkdzY/vcn5LBISrzXhf8fW27Pdga\r\n"
//			+ "Va38QA7MXVUv/J9xv01m7JFXgdJmTkUc6Y/Y1g+AF+aT/wXnduuL1FqQGRZe1lBq7VMVAgMBAAEC\r\n"
//			+ "gYEAkhWTI4YASCDsmAHRDs1K9kYKXi/StUhxjp/+qJMbUGoDGSZe3HfMmmkLNVpJykKx7SyYEORC\r\n"
//			+ "it5L3qSl0fuInJDsw2U8F8KLtUuiOsgizTufmas2rZjy/QByd9hs6BSfdfQtSp/fjrZKIE42WXc6\r\n"
//			+ "hn2C6rJmvJShn1/jY5SElOECQQDVV+ExlAVGUURmAvJqOBWuiQj9cpSfaoK4qYO0x828gRQrhPj4\r\n"
//			+ "PiU/jmqAFA3OVEOBumyoXbWrfLASzJryjfoJAkEAshvE56zBLurcfDHn68c5vv8vQ7WX1URDBoFT\r\n"
//			+ "LA/s2Te7+w5kscOtGEY9uynTpV0q+oSbur+Z37FP1rqrcvNDrQJAUgv9+wcmECjo2SKBAACZtgnV\r\n"
//			+ "f0M1jSl1JHdsw3Wj1b7+ds4owa+Eu7CVnLQZqyQU4itD5mxDlbPaMyCk5mtboQJBAJtpEaJZomNu\r\n"
//			+ "+Z7A6S5Zs3COOE6riGXF33owpENBThinwjYpdAGMzV/uAnVq5MtZBWR9C2mjP//pNtIWJf3yeC0C\r\n"
//			+ "QGTr1qTPImKLSbD0Z5CXbFuyRuflc4JS+LKVH9uoV55kBdZyJVfFAWiTDNFCcOjgOyBnydk1g6fX\r\n" + "sDuA8UE7uPg=";
//	/**
//	 * 由字节数组用Base64编码成的公钥
//	 */
//	public static String publicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCUbj7xk9R6KyEXuVNUhQ+6Jpq3vxJkd1VM75n8\r\n"
//			+ "IBmrTONeaCcY6FyAL+dKf7FmxwLIHZTWOnG452ZHc2P73J+SwSEq814X/H1tuz3YGlWt/EAOzF1V\r\n"
//			+ "L/yfcb9NZuyRV4HSZk5FHOmP2NYPgBfmk/8F53bri9RakBkWXtZQau1TFQIDAQAB";
//
//	/**
//	 * 生成一对公钥-私钥。 <br>
//	 * <br>
//	 * 创建人： 袁炜林 <br>
//	 * 创建时间： 2017年10月28日 下午4:54:05 <br>
//	 *
//	 * @param keySize
//	 * @return
//	 * @throws NoSuchAlgorithmException
//	 */
//	public static KeyPair generateKeyPair(int keySize) throws NoSuchAlgorithmException {
//		KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
//		keyPairGen.initialize(keySize);
//		return keyPairGen.generateKeyPair();
//	}
//
//	/**
//	 * 从密钥对中取得私钥。 <br>
//	 * <br>
//	 * 创建人： 袁炜林 <br>
//	 * 创建时间： 2017年10月28日 下午4:56:45 <br>
//	 *
//	 * @param pair
//	 * @return
//	 */
//	public static Key getPriKeyFromPair(KeyPair pair) {
//		return pair.getPrivate();
//	}
//
//	/**
//	 * 从密钥对中取得公钥。 <br>
//	 * <br>
//	 * 创建人： 袁炜林 <br>
//	 * 创建时间： 2017年10月28日 下午4:56:45 <br>
//	 *
//	 * @param pair
//	 * @return
//	 */
//	public static Key getPubKeyFromPair(KeyPair pair) {
//		return pair.getPublic();
//	}
//
//	/**
//	 * 从 .p12 文件中读取私钥。 <br>
//	 * <br>
//	 * 创建人： 袁炜林 <br>
//	 * 创建时间： 2017年10月28日 下午4:21:56 <br>
//	 *
//	 * @param pfxKeyFileName
//	 *            .p12文件路径
//	 * @param aliasName
//	 *            私钥别名
//	 * @param pfxPassword
//	 *            私钥密码
//	 * @return 私钥对象
//	 * @throws KeyStoreException
//	 * @throws NoSuchAlgorithmException
//	 * @throws CertificateException
//	 * @throws IOException
//	 * @throws UnrecoverableKeyException
//	 */
//	public static PrivateKey readP12Key(String pfxKeyFileName, String aliasName, String pfxPassword)
//			throws KeyStoreException, NoSuchAlgorithmException, CertificateException, IOException,
//			UnrecoverableKeyException {
//		InputStream fis = new FileInputStream(pfxKeyFileName);
//		KeyStore keyStore = KeyStore.getInstance("PKCS12");
//		keyStore.load(fis, pfxPassword.toCharArray());
//		return (PrivateKey) keyStore.getKey(aliasName, pfxPassword.toCharArray());
//	}
//
//	public static PublicKey readCerKey(String cerKeyFileName) {
//		return null;
//	}
//
//	/**
//	 * key转Base64字符串。 <br>
//	 * <br>
//	 * 创建人： 袁炜林 <br>
//	 * 创建时间： 2017年10月28日 下午4:59:15 <br>
//	 *
//	 * @param key
//	 * @return
//	 */
//	public static String keyToBase64(Key key) {
//		return encryptBase64(key.getEncoded());
//	}
//
//	/**
//	 * Base64串转私钥。 <br>
//	 * <br>
//	 * 创建人： 袁炜林 <br>
//	 * 创建时间： 2017年10月28日 下午5:14:20 <br>
//	 *
//	 * @param base64Key
//	 * @return
//	 * @throws NoSuchAlgorithmException
//	 * @throws InvalidKeySpecException
//	 */
//	public static PrivateKey base64ToPriKey(String base64Key) throws NoSuchAlgorithmException, InvalidKeySpecException {
//		//解密由base64编码的私钥
//		byte[] keyBytes = decryptBase64(base64Key);
//
//		//构造PKCS8EncodedKeySpec对象
//		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
//
//		//KEY_ALGORITHM 指定的加密算法
//		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
//
//		//取私钥匙对象
//		return keyFactory.generatePrivate(pkcs8KeySpec);
//	}
//
//	/**
//	 * Base64串转公钥。 <br>
//	 * <br>
//	 * 创建人： 袁炜林 <br>
//	 * 创建时间： 2017年10月28日 下午5:14:33 <br>
//	 *
//	 * @param base64
//	 * @return
//	 * @throws NoSuchAlgorithmException
//	 * @throws InvalidKeySpecException
//	 */
//	public static PublicKey base64ToPubKey(String base64) throws NoSuchAlgorithmException, InvalidKeySpecException {
//		//解密由base64编码的公钥
//		byte[] keyBytes = decryptBase64(publicKey);
//
//		//构造X509EncodedKeySpec对象
//		X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
//
//		//KEY_ALGORITHM 指定的加密算法
//		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
//
//		//取公钥匙对象
//		return keyFactory.generatePublic(keySpec);
//	}
//
//	/**
//	 * 用私钥加密。 <br>
//	 * <br>
//	 * 创建人： 袁炜林 <br>
//	 * 创建时间： 2017年10月25日 下午12:53:34 <br>
//	 *
//	 * @param data
//	 *            明文（String.getBytes得到的字节数组）
//	 * @param base64Key
//	 *            私钥字符串
//	 * @param paddingType
//	 *            填充类型
//	 * @return 密文字节数组
//	 * @throws InvalidKeySpecException
//	 * @throws NoSuchAlgorithmException
//	 * @throws NoSuchPaddingException
//	 * @throws InvalidKeyException
//	 * @throws BadPaddingException
//	 * @throws IllegalBlockSizeException
//	 * @throws Exception
//	 */
//	public static byte[] encryptByPrivateKey(byte[] data, String base64Key, String paddingType)
//			throws NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException, InvalidKeyException,
//			IllegalBlockSizeException, BadPaddingException {
//		//转换私钥
//		Key privateKey = base64ToPriKey(base64Key);
//
//		//对数据加密
//		Cipher cipher = Cipher.getInstance(paddingType);
//		cipher.init(Cipher.ENCRYPT_MODE, privateKey);
//		return cipher.doFinal(data);
//	}
//
//	/**
//	 * 用私钥加密：字符串到字符串。 <br>
//	 * <br>
//	 * 创建人： 袁炜林 <br>
//	 * 创建时间： 2017年10月24日 下午1:56:13 <br>
//	 *
//	 * @param data
//	 *            明文字符串
//	 * @param base64Key
//	 *            私钥字符串
//	 * @param charset
//	 *            字符编码
//	 * @param paddingType
//	 *            填充类型
//	 * @return 密文字节数组用Base64算法编码成的字符串，方便传输、储存
//	 * @throws UnsupportedEncodingException
//	 * @throws BadPaddingException
//	 * @throws IllegalBlockSizeException
//	 * @throws NoSuchPaddingException
//	 * @throws InvalidKeySpecException
//	 * @throws NoSuchAlgorithmException
//	 * @throws InvalidKeyException
//	 */
//	public static String encryptByPrivateKey(String data, String base64Key, String charset, String paddingType)
//			throws InvalidKeyException, NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException,
//			IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
//		//统一用UTF-8编码转字节数组，避免网络传输时的乱码问题
//		return encryptBase64(encryptByPrivateKey(data.getBytes(charset), base64Key, paddingType));
//	}
//
//	/**
//	 * 用私钥加密：字符串到字符串（默认使用填充方式加密）。 <br>
//	 * <br>
//	 * 创建人： 袁炜林 <br>
//	 * 创建时间： 2017年11月3日 下午9:45:52 <br>
//	 *
//	 * @param data
//	 *            明文字符串
//	 * @param base64Key
//	 *            私钥字符串
//	 * @param charset
//	 *            字符编码
//	 * @return 密文字节数组用Base64算法编码成的字符串，方便传输、储存
//	 * @throws UnsupportedEncodingException
//	 * @throws BadPaddingException
//	 * @throws IllegalBlockSizeException
//	 * @throws NoSuchPaddingException
//	 * @throws InvalidKeySpecException
//	 * @throws NoSuchAlgorithmException
//	 * @throws InvalidKeyException
//	 */
//	public static String encryptByPrivateKey(String data, String base64Key, String charset)
//			throws InvalidKeyException, NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException,
//			IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
//		//统一用UTF-8编码转字节数组，避免网络传输时的乱码问题
//		return encryptBase64(encryptByPrivateKey(data.getBytes(charset), base64Key, RSACoder.PADDING));
//	}
//
//	/**
//	 * 用公钥加密。 <br>
//	 * <br>
//	 * 创建人： 袁炜林 <br>
//	 * 创建时间： 2017年10月25日 下午1:05:09 <br>
//	 *
//	 * @param data
//	 *            明文（String.getBytes得到的字节数组）
//	 * @param base64Key
//	 *            公钥字符串
//	 * @param paddingType
//	 *            填充类型
//	 * @return 密文字节数组
//	 * @throws InvalidKeySpecException
//	 * @throws NoSuchAlgorithmException
//	 * @throws NoSuchPaddingException
//	 * @throws InvalidKeyException
//	 * @throws BadPaddingException
//	 * @throws IllegalBlockSizeException
//	 * @throws Exception
//	 */
//	public static byte[] encryptByPublicKey(byte[] data, String base64Key, String paddingType)
//			throws NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException, InvalidKeyException,
//			IllegalBlockSizeException, BadPaddingException {
//		Key publicKey = base64ToPubKey(base64Key);
//
//		//对数据加密
//		Cipher cipher = Cipher.getInstance(paddingType);
//		cipher.init(Cipher.ENCRYPT_MODE, publicKey);
//
//		return cipher.doFinal(data);
//	}
//
//	/**
//	 * 用公钥加密：字符串到字符串。 <br>
//	 * <br>
//	 * 创建人： 袁炜林 <br>
//	 * 创建时间： 2017年10月24日 下午2:00:49 <br>
//	 *
//	 * @param data
//	 *            明文字符串
//	 * @param base64Key
//	 *            公钥字符串
//	 * @param charset
//	 *            字符编码
//	 * @param paddingType
//	 *            填充类型
//	 * @return 密文字节数组用Base64算法编码成的字符串，方便传输、储存
//	 * @throws UnsupportedEncodingException
//	 * @throws BadPaddingException
//	 * @throws IllegalBlockSizeException
//	 * @throws NoSuchPaddingException
//	 * @throws InvalidKeySpecException
//	 * @throws NoSuchAlgorithmException
//	 * @throws InvalidKeyException
//	 */
//	public static String encryptByPublicKey(String data, String base64Key, String charset, String paddingType)
//			throws InvalidKeyException, NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException,
//			IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
//		//统一用UTF-8编码转字节数组，避免网络传输时的乱码问题
//		return encryptBase64(encryptByPublicKey(data.getBytes(charset), base64Key, paddingType));
//	}
//
//	/**
//	 * 用公钥加密：字符串到字符串（默认使用填充方式加密，每次加密的字符串都不一样，更安全）。 <br>
//	 * <br>
//	 * 创建人： 袁炜林 <br>
//	 * 创建时间： 2017年11月3日 下午9:47:11 <br>
//	 *
//	 * @param data
//	 *            明文字符串
//	 * @param base64Key
//	 *            公钥字符串
//	 * @param charset
//	 *            字符编码
//	 * @return 密文字节数组用Base64算法编码成的字符串，方便传输、储存
//	 * @throws UnsupportedEncodingException
//	 * @throws BadPaddingException
//	 * @throws IllegalBlockSizeException
//	 * @throws NoSuchPaddingException
//	 * @throws InvalidKeySpecException
//	 * @throws NoSuchAlgorithmException
//	 * @throws InvalidKeyException
//	 */
//	public static String encryptByPublicKey(String data, String base64Key, String charset)
//			throws InvalidKeyException, NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException,
//			IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
//		//统一用UTF-8编码转字节数组，避免网络传输时的乱码问题
//		return encryptBase64(encryptByPublicKey(data.getBytes(charset), base64Key, RSACoder.PADDING));
//	}
//
//	/**
//	 * 用公钥解密。 <br>
//	 * <br>
//	 * 创建人： 袁炜林 <br>
//	 * 创建时间： 2017年10月25日 下午12:59:07 <br>
//	 *
//	 * @param data
//	 *            密文字节数组
//	 * @param base64Key
//	 *            公钥字符串
//	 * @param paddingType
//	 *            填充类型
//	 * @return 明文字节数组
//	 * @throws InvalidKeySpecException
//	 * @throws NoSuchAlgorithmException
//	 * @throws NoSuchPaddingException
//	 * @throws InvalidKeyException
//	 * @throws BadPaddingException
//	 * @throws IllegalBlockSizeException
//	 */
//	public static byte[] decryptByPublicKey(byte[] data, String base64Key, String paddingType)
//			throws NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException, InvalidKeyException,
//			IllegalBlockSizeException, BadPaddingException {
//		Key publicKey = base64ToPubKey(base64Key);
//
//		//对数据解密
//		Cipher cipher = Cipher.getInstance(paddingType);
//		cipher.init(Cipher.DECRYPT_MODE, publicKey);
//
//		return cipher.doFinal(data);
//	}
//
//	/**
//	 * 用公钥解密：字符串到字符串。 <br>
//	 * <br>
//	 * 创建人： 袁炜林 <br>
//	 * 创建时间： 2017年10月24日 下午2:02:17 <br>
//	 *
//	 * @param data
//	 *            密文字符串（由密文字节数组用Base64算法编码成的字符串）
//	 * @param base64Key
//	 *            公钥字符串
//	 * @param charset
//	 *            字符编码
//	 * @param paddingType
//	 *            填充类型
//	 * @return 明文字符串
//	 * @throws BadPaddingException
//	 * @throws IllegalBlockSizeException
//	 * @throws NoSuchPaddingException
//	 * @throws InvalidKeySpecException
//	 * @throws NoSuchAlgorithmException
//	 * @throws UnsupportedEncodingException
//	 * @throws InvalidKeyException
//	 */
//	public static String decryptByPublicKey(String data, String base64Key, String charset, String paddingType)
//			throws InvalidKeyException, UnsupportedEncodingException, NoSuchAlgorithmException, InvalidKeySpecException,
//			NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
//		//先解密Base64字符串，再解密。注意统一用UTF-8解码转字符串，避免网络传输的乱码问题
//		return new String(decryptByPublicKey(decryptBase64(data), base64Key, paddingType), charset);
//	}
//
//	/**
//	 * 用公钥解密：字符串到字符串（默认使用填充方式加密）。 <br>
//	 * <br>
//	 * 创建人： 袁炜林 <br>
//	 * 创建时间： 2017年11月3日 下午9:49:37 <br>
//	 *
//	 * @param data
//	 *            密文字符串（由密文字节数组用Base64算法编码成的字符串）
//	 * @param base64Key
//	 *            公钥字符串
//	 * @param charset
//	 *            字符编码
//	 * @return 明文字符串
//	 * @throws BadPaddingException
//	 * @throws IllegalBlockSizeException
//	 * @throws NoSuchPaddingException
//	 * @throws InvalidKeySpecException
//	 * @throws NoSuchAlgorithmException
//	 * @throws UnsupportedEncodingException
//	 * @throws InvalidKeyException
//	 */
//	public static String decryptByPublicKey(String data, String base64Key, String charset)
//			throws InvalidKeyException, UnsupportedEncodingException, NoSuchAlgorithmException, InvalidKeySpecException,
//			NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
//		//先解密Base64字符串，再解密。注意统一用UTF-8解码转字符串，避免网络传输的乱码问题
//		return new String(decryptByPublicKey(decryptBase64(data), base64Key, RSACoder.PADDING), charset);
//	}
//
//	/**
//	 * 用私钥解密。 <br>
//	 * <br>
//	 * 创建人： 袁炜林 <br>
//	 * 创建时间： 2017年10月25日 下午1:06:43 <br>
//	 *
//	 * @param data
//	 *            密文字节数组
//	 * @param base64Key
//	 *            私钥字符串
//	 * @param paddingType
//	 *            填充类型
//	 * @return 明文字节数组
//	 * @throws InvalidKeySpecException
//	 * @throws NoSuchAlgorithmException
//	 * @throws NoSuchPaddingException
//	 * @throws InvalidKeyException
//	 * @throws BadPaddingException
//	 * @throws IllegalBlockSizeException
//	 */
//	public static byte[] decryptByPrivateKey(byte[] data, String base64Key, String paddingType)
//			throws NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException, InvalidKeyException,
//			IllegalBlockSizeException, BadPaddingException {
//		//转换私钥
//		Key privateKey = base64ToPriKey(base64Key);
//
//		//对数据解密
//		Cipher cipher = Cipher.getInstance(paddingType);
//		cipher.init(Cipher.DECRYPT_MODE, privateKey);
//
//		return cipher.doFinal(data);
//	}
//
//	/**
//	 * 用私钥解密：字符串到字符串。 <br>
//	 * <br>
//	 * 创建人： 袁炜林 <br>
//	 * 创建时间： 2017年10月24日 下午1:57:42 <br>
//	 *
//	 * @param data
//	 *            密文字符串（由密文字节数组用Base64算法编码成的字符串）
//	 * @param key
//	 *            私钥字符串
//	 * @param charset
//	 *            字符编码
//	 * @param paddingType
//	 *            填充类型
//	 * @return 明文字符串
//	 * @throws BadPaddingException
//	 * @throws IllegalBlockSizeException
//	 * @throws NoSuchPaddingException
//	 * @throws InvalidKeySpecException
//	 * @throws NoSuchAlgorithmException
//	 * @throws UnsupportedEncodingException
//	 * @throws InvalidKeyException
//	 */
//	public static String decryptByPrivateKey(String data, String key, String charset, String paddingType)
//			throws InvalidKeyException, UnsupportedEncodingException, NoSuchAlgorithmException, InvalidKeySpecException,
//			NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
//		//先解密Base64字符串，再解密。注意统一用UTF-8解码转字符串，避免网络传输的乱码问题
//		return new String(decryptByPrivateKey(decryptBase64(data), key, paddingType), charset);
//	}
//
//	/**
//	 * 用私钥解密：字符串到字符串（默认使用填充方式加密，每次加密的字符串都不一样，更安全）。 <br>
//	 * <br>
//	 * 创建人： 袁炜林 <br>
//	 * 创建时间： 2017年10月24日 下午1:57:42 <br>
//	 *
//	 * @param data
//	 *            密文字符串（由密文字节数组用Base64算法编码成的字符串）
//	 * @param key
//	 *            私钥字符串
//	 * @param charset
//	 *            字符编码
//	 * @return 明文字符串
//	 * @throws UnsupportedEncodingException
//	 * @throws Exception
//	 */
//	public static String decryptByPrivateKey(String data, String key, String charset)
//			throws UnsupportedEncodingException, Exception {
//		//先解密Base64字符串，再解密。注意统一用UTF-8解码转字符串，避免网络传输的乱码问题
//		return new String(decryptByPrivateKey(decryptBase64(data), key, RSACoder.PADDING), charset);
//	}
//
//	public static void main(String[] args) {
//		try {
//			//setUp();
//			//testPubToPri();
//			testSignAndVerify();
//		} catch (Exception e) {
//			//TODO Auto-generated catch block
//			logger.error(null, e);
//		}
//
//	}
//
//	/**
//	 * 测试公钥加密——私钥解密 <br>
//	 * <br>
//	 * 创建人： 袁炜林 <br>
//	 * 创建时间： 2017年10月24日 下午1:54:05 <br>
//	 *
//	 * @throws Exception
//	 */
//	public static void testPubToPri() throws Exception {
//		System.err.println("公钥加密——私钥解密");
//		String inputStr = "哈哈哈";
//
//		//byte[] data = inputStr.getBytes();
//		//byte[] encodedData = RSACoder.encryptByPublicKey(data, publicKey);
//		//logger.info("密文：" + new String(encodedData));
//		//
//		//Base64 base64 = new Base64();
//		//String cipherTextBase64 = base64.encodeToString(encodedData);
//		//
//		////get cipher binary data back from String
//		//byte[] cipherTextArray = base64.decode(cipherTextBase64);
//		//
//		//byte[] decodedData = RSACoder.decryptByPrivateKey(cipherTextArray,
//		//privateKey);
//		////byte[] decodedData =
//		//RSACoder.decryptByPrivateKey("HorHo4e5xU4XdqAzd2Yo26zwBK0RP7TvhyGfPLzGjXV5WvMYUUrEreh7d6TPAoGKZh+KyeOsGZul8CvuswOVBxOuy+25EMEK1yLHi5wQf45ejjXpU56sX9A2O5sZ948Qm4ssjdTlkTy+VqfZzvU22gbWQuVhXI43kwKuLsTMaUWttBez/nYPTeQaGIIyVikdXqPWwUlWAL8ScNy3V17S5FQ8?WuhruB0BtMuIy4oUmgrIT8HQxCO70+wJuNCmRGtsBcs=".getBytes(),
//		////privateKey);
//		//String outputStr = new String(decodedData);
//		//System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);
//
//		//加密
//		String encodedData = encryptByPublicKey(inputStr, publicKey, "UTF-8");
//		//String encodedData =
//		//"GgVG4XHIQJfw2RGLRXoHttGqT/AZ8bKQRd7noyG0vlIXIYbY/5LAvxWGJpGIih9Z3ufQJMzjJ2jEyFFteUKI7hy3zdixLyXuSBG6cua8rPGutzNo5rgSftauM49q24eDXUeX1fLkRsB9ZKmu7iIVz4E2DNMrK1PuSgp3NYRHkSE=";
//		logger.info("密文：" + encodedData);
//
//		//解密
//		String outputStr = decryptByPrivateKey(encodedData, privateKey, "UTF-8");
//		System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);
//		//assertEquals(inputStr, outputStr);
//
//	}
//
//	/**
//	 * 签名、验证测试：私钥加密——公钥解密 <br>
//	 * <br>
//	 * 创建人： 袁炜林 <br>
//	 * 创建时间： 2017年10月24日 下午1:54:21 <br>
//	 *
//	 * @throws Exception
//	 */
//	public static void testSignAndVerify() throws Exception {
//
//		System.err.println("私钥加密——公钥解密");
//		String inputStr = "sign";
//
//		//byte[] data = inputStr.getBytes();
//		//
//		//byte[] encodedData = RSACoder.encryptByPrivateKey(data, privateKey);
//		//
//		//byte[] decodedData = RSACoder
//		//.decryptByPublicKey(encodedData, publicKey);
//
//		//String outputStr = new String(decodedData);
//		//System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);
//		//assertEquals(inputStr, outputStr);
//
//		String encodedData = RSACoder.encryptByPrivateKey(inputStr, privateKey, "UTF-8");
//		System.err.println("密文：" + encodedData);
//		String decodedData = RSACoder.decryptByPublicKey(encodedData, publicKey, "UTF-8");
//
//		System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + decodedData);
//		//assertEquals(inputStr, decodedData);
//
//		//System.err.println("私钥签名——公钥验证签名");
//		////产生签名
//		//String sign = RSACoder.signToBase64(encodedData, privateKey);
//		//System.err.println("签名:\r" + sign);
//		//
//		////验证签名
//		//boolean status = RSACoder.verifyFromBase64(encodedData, publicKey, sign);
//		//System.err.println("状态:\r" + status);
//		////assertTrue(status);
//
//	}
//}
